home *** CD-ROM | disk | FTP | other *** search
/ FishMarket 1.0 / FishMarket v1.0.iso / fishies / 201-225 / disk_223 / csh / comm2.c < prev    next >
C/C++ Source or Header  |  1992-05-06  |  13KB  |  600 lines
  1. /*
  2.  * COMM2.C
  3.  *
  4.  * (c)1986 Matthew Dillon     9 October 1986
  5.  *
  6.  * Version 2.07M by Steve Drew 10-Sep-87
  7.  *
  8.  * Version 3.03A by Carlo Borreo & Cesare Dieni 12-May-89
  9.  *
  10.  */
  11.  
  12. extern char *v_gotofwd;
  13.  
  14. /* Casting conveniences */
  15. #define BPTR_TO_C(strtag, var)  ((struct strtag *)(BADDR( (ULONG) var)))
  16. #define PROC(task)              ((struct Process *)task)
  17. #define CLI(proc)               (BPTR_TO_C(CommandLineInterface, proc->pr_CLI))
  18.  
  19. /* Externs */
  20. extern int has_wild;                    /* flag set if any arg has a ? or * */
  21.  
  22. /* globals */
  23. int cp_update;
  24. int cp_date;
  25.  
  26. do_abortline()
  27. {
  28. Exec_abortline = 1;
  29. return 0;
  30. }
  31.  
  32. do_return()
  33. {
  34. register int retcode=(ac<2 ? 0 : atoi(av[1]));
  35.    Exec_abortline = 1;
  36.    if (Src_stack) {
  37.        FILE *ptr = (FILE *)Src_base[Src_stack - 1];
  38.        ptr->_bp = ptr->_bend;
  39.        ptr->_flags |= _EOF;
  40. /*     fseek (Src_base[Src_stack - 1], 0L, 2); */
  41.       return retcode;
  42.    } else main_exit(retcode);
  43. }
  44.  
  45. /*
  46.  * STRHEAD
  47.  *
  48.  * place a string into a variable removing everything after and including
  49.  * the 'break' character
  50.  *
  51.  * strhead varname breakchar string
  52.  *
  53.  */
  54.  
  55. do_strhead()
  56. {
  57. char *s;
  58. if (s=index(av[3],*av[2])) *s='\0';
  59. set_var (LEVEL_SET, av[1], av[3]);
  60. return 0;
  61. }
  62.  
  63. do_strtail()
  64. {
  65. char *s;
  66. if (s=index(av[3],*av[2])) s++; else s=av[3];
  67. set_var (LEVEL_SET, av[1], s);
  68. return 0;
  69. }
  70.  
  71. long dptrtosecs(d)
  72. struct DPTR *d;
  73. {
  74. register struct DateStamp *ds=(&d->fib->fib_Date);
  75. return ds->ds_Days*86400 + ds->ds_Minute*60 + ds->ds_Tick/TICKS_PER_SECOND;
  76. }
  77.  
  78. long timeof(s)
  79. char *s;
  80. {
  81. struct DPTR *d;
  82. int dummy;
  83. long n;
  84.  
  85. if ( (d=dopen(s,&dummy))==NULL ) return 0L;
  86. n=dptrtosecs(d);
  87. dclose(d);
  88. return n;
  89. }
  90.  
  91. /*
  92.  * if -f file (exists) or:
  93.  *
  94.  * if A < B   <, >, =, <=, >=, <>, where A and B are either:
  95.  * nothing
  96.  * a string
  97.  * a value (begins w/ number)
  98.  */
  99.  
  100. do_if(garbage, com)
  101. char *garbage;
  102. {
  103. int result;
  104. int i;
  105.  
  106. switch (com) {
  107.     case 0:
  108.     if (If_stack && If_base[If_stack - 1]) If_base[If_stack++] = 1;
  109.     else {
  110.         get_opt("rftmdn",&i);
  111.         result=evalif(i);
  112.         If_base[If_stack++]=(options & 32 ? result : !result);
  113.         }
  114.     break;
  115.     case 1:
  116.     if (If_stack > 1 && If_base[If_stack - 2]) break;
  117.     if (If_stack) If_base[If_stack - 1] ^= 1;
  118.     break;
  119.     case 2:
  120.     if (If_stack) --If_stack;
  121.     break;
  122.      }
  123. disable = (If_stack) ? If_base[If_stack - 1] : 0;
  124. if (If_stack >= MAXIF) {
  125.     fprintf(stderr,"If's too deep\n");
  126.     disable = If_stack = 0;
  127.     return -1;
  128.     }
  129. if (forward_goto) disable = If_base[If_stack - 1] = 0;
  130. return 0;
  131. }
  132.  
  133. evalif(i)
  134. register unsigned int i;
  135. {
  136. char c;
  137. long num, t0;
  138. long AvailMem();
  139.  
  140. switch(options & ~32) {
  141.     case 0:
  142.     if (ac-i != 3) return (ac>i && *av[i]);
  143.     Errno=0;
  144.     num=Atol(av[i])-Atol(av[i+2]);
  145.     if (Errno) num=strcmp(av[i],av[i+2]);
  146.     if (num < 0)       c='<';
  147.     else if (num > 0)  c='>';
  148.     else if (num == 0) c='=';
  149.     return index(av[i+1], c) != NULL;
  150.     case 1:
  151.     return do_rpn(NULL,i);
  152.     case 2:
  153.     return exists(av[i]);
  154.     case 4:
  155.     t0=timeof(av[i++]);
  156.     for ( ; i<ac ; i++)
  157.         if (t0<=timeof(av[i])) return 1;
  158.     return 0;
  159.     case 8:
  160.     return (AvailMem( (long)MEMF_FAST )!=0);
  161.     case 16:
  162.     return (isdir(av[i])!=0);
  163.     default:
  164.     ierror(NULL,500);
  165.     return 0;
  166.     }
  167. }
  168.  
  169. do_label()
  170. {
  171.    char aseek[32];
  172.  
  173.    if (Src_stack == 0) {
  174.       ierror (NULL, 502);
  175.       return (-1);
  176.    }
  177.  
  178.    sprintf (aseek, "%ld %d", Src_pos[Src_stack-1], If_stack);
  179.    set_var (LEVEL_LABEL + Src_stack - 1, av[1], aseek);
  180.    if (!strcmp(av[1],get_var(LEVEL_SET,v_gotofwd)))
  181.       forward_goto = 0;
  182.    return 0;
  183. }
  184.  
  185. do_goto()
  186. {
  187.    int new;
  188.    long pos;
  189.    char *lab;
  190.  
  191.    if (Src_stack == 0) {
  192.       ierror (NULL, 502);
  193.    } else {
  194.       lab = get_var (LEVEL_LABEL + Src_stack - 1, av[1]);
  195.       if (lab == NULL) {
  196.          forward_goto = 1;
  197.          set_var (LEVEL_SET, v_gotofwd, av[1]);
  198.          return(0);
  199.       } else {
  200.          pos = atoi(lab);
  201.          fseek (Src_base[Src_stack - 1], pos, 0);
  202.          Src_pos[Src_stack - 1] = pos;
  203.          new = atoi(next_word(lab));
  204.          for (; If_stack < new; ++If_stack)
  205.             If_base[If_stack] = 0;
  206.          If_stack = new;
  207.       }
  208.    }
  209.    Exec_abortline = 1;
  210.    return (0);      /* Don't execute rest of this line */
  211. }
  212.  
  213.  
  214. do_inc(garbage, com)
  215. char *garbage;
  216. {
  217. char *var, num[32];
  218.  
  219. if (ac>2) com *= atoi(av[2]);
  220. if (var = get_var (LEVEL_SET, av[1])) {
  221.     sprintf (num, "%d", atoi(var)+com);
  222.     set_var (LEVEL_SET, av[1], num);
  223.     }
  224. return 0;
  225. }
  226.  
  227. do_input()
  228. {
  229. char in[256], *p,*s;
  230. unsigned int i;
  231.  
  232. for (i=1; i < ac; ++i)
  233.     if (gets(in)) {
  234.     for(p = in; *p; p = s) {
  235.         s = next_word(p);
  236.         if (*s) *(s-1) = 0xA0;
  237.         }
  238.     set_var (LEVEL_SET, av[i], in);
  239.     }
  240. return 0;
  241. }
  242.  
  243. do_ver()
  244. {
  245. puts("Shell V3.03A\n\
  246. )1986 Matthew Dillon\n\
  247. Manx (M) versions by Steve Drew\n\
  248. ARP (A) versions by Carlo Borreo & Cesare Dieni\n");
  249. return 0;
  250. }
  251.  
  252. do_ps()
  253. {
  254. /* this code fragment based on ps.c command by Dewi Williams */
  255.  
  256. register int    count;        /* loop variable        */
  257. struct Task    *task;        /* EXEC descriptor        */
  258. char        strbuf[64+1];    /* scratch for btocstr()    */
  259. char        cmd[40+1];    /* holds cmd name        */
  260. long ncli;
  261.  
  262. printf("Proc Command Name         CLI Type    Pri.  Address  Directory\n");
  263. Forbid();
  264.  
  265. ncli=(long)FindCLI(0L);
  266. for (count = 1; count <= ncli ; count++)
  267.         /* or just assume 20?*/
  268.     if (task = (struct Task *)FindCLI((long)count)) {
  269.     if (task==NULL) continue;
  270.     /* Sanity check just in case */
  271.     if (PROC(task)->pr_TaskNum == 0 || PROC(task)->pr_CLI == 0) continue;
  272.                             /* or complain? */
  273.     BtoCStr(cmd,   CLI(PROC(task))->cli_CommandName, 40L);
  274.     BtoCStr(strbuf,CLI(PROC(task))->cli_SetName    , 64L);
  275.     printf("%2d   %-20.20s %-11.11s %3d  %8lx  %s\n",
  276.         count,
  277.         cmd,
  278.         task->tc_Node.ln_Name,
  279.         task->tc_Node.ln_Pri,
  280.         task,
  281.         strbuf);
  282.     }
  283. Permit();
  284. return 0;
  285. }
  286.  
  287. /*
  288.  * CP [-d] [-u] file file
  289.  * CP [-d] [-u] file file file... destdir
  290.  * CP [-r][-u][-d] dir dir dir... destdir
  291.  */
  292.  
  293. char *errstr;          /* let's be alittle more informative */
  294.  
  295. do_copy()
  296. {
  297. register int recur, ierr;
  298. register char *destname;
  299. register char destisdir;
  300. register FIB *fib;
  301. int i;
  302.  
  303. errstr = "";
  304. ierr = 0;
  305.  
  306. fib = (FIB *)AllocMem((long)sizeof(FIB), MEMF_PUBLIC);
  307.  
  308. get_opt("rud",&i);
  309. recur     = (options & 0x01);
  310. cp_update = (options & 0x02);
  311. cp_date   = (!(options & 0x04)); /* the default is keep orignal file date */
  312.  
  313. destname = av[ac - 1];
  314.  
  315. if (ac < i + 2) {
  316.     ierr = 500;
  317.     goto done;
  318.     }
  319. destisdir = isdir(destname);
  320. if (ac > i + 2 && !destisdir) {
  321.     ierr = 507;
  322.     goto done;
  323.     }
  324.  
  325. /*
  326.  * copy set:                        reduce to:
  327.  *    file to file                     file to file
  328.  *    dir  to file (NOT ALLOWED)
  329.  *    file to dir                      dir to dir
  330.  *    dir  to dir                      dir to dir
  331.  *
  332.  */
  333.  
  334. for (; i<ac-1 && !dobreak(); ++i) {
  335.     short srcisdir = isdir(av[i]);
  336.     if (srcisdir && has_wild && (ac >2)) /* hack to stop dir's from */
  337.         continue;             /* getting copied if specified */
  338.                          /* from wild expansion */
  339.     if (srcisdir) {
  340.         BPTR srcdir, destdir;
  341.         if (!destisdir) {
  342.             if (exists(destname)) {
  343.                 ierr = 507;    /* disallow dir to file */
  344.                 goto done;
  345.                 }
  346.             if (destdir = CreateDir(destname)) UnLock(destdir);
  347.             destisdir = 1;
  348.             }
  349.         if (!(destdir = Lock(destname, ACCESS_READ))) {
  350.             ierr = 205;
  351.             errstr = destname;
  352.             goto done;
  353.             }
  354.         if (!(srcdir = Lock(av[i], ACCESS_READ))) {
  355.             ierr = 205;
  356.             errstr = av[i];
  357.             UnLock(destdir);
  358.             goto done;
  359.             }
  360.         ierr = copydir(srcdir, destdir, recur);
  361.         UnLock(srcdir);
  362.         UnLock(destdir);
  363.         if (ierr) break;
  364.         }
  365.     else {        /* FILE to DIR,   FILE to FILE   */
  366.         BPTR destdir, srcdir, tmp;
  367.         char *destfilename;
  368.  
  369.         srcdir = (BPTR)(Myprocess->pr_CurrentDir);
  370.  
  371.         if ((tmp = Lock(av[i], ACCESS_READ)) == NULL || !Examine(tmp,fib)) {
  372.             if (tmp) UnLock(tmp);
  373.             ierr = 205;
  374.             errstr = av[i];
  375.             goto done;
  376.             }
  377.         UnLock(tmp);
  378.         if (destisdir) {
  379.             destdir = Lock(destname, ACCESS_READ);
  380.             destfilename = fib->fib_FileName;
  381.             }
  382.         else {
  383.             destdir = srcdir;
  384.             destfilename = destname;
  385.             }
  386.         printf(" %s..",av[i]);
  387.         fflush(stdout);
  388.         ierr = copyfile(av[i], srcdir, destfilename, destdir);
  389.         if (destisdir) UnLock(destdir);
  390.         if (ierr) break;
  391.         }
  392.     }
  393.  
  394. done:
  395.  
  396. FreeMem(fib, (long)sizeof(FIB));
  397. if (ierr) {
  398.     ierror(errstr, ierr);
  399.     return(20);
  400.     }
  401. return 0;
  402. }
  403.  
  404.  
  405. copydir(srcdir, destdir, recur)
  406. register BPTR srcdir, destdir;
  407. {
  408.    BPTR cwd;
  409.    register FIB *srcfib;
  410.    register BPTR destlock, srclock;
  411.    int ierr;
  412.    static int level;
  413.  
  414.    level++;
  415.    ierr = 0;
  416.    srcfib = (FIB *)AllocMem((long)sizeof(FIB), MEMF_PUBLIC);
  417.    if (Examine(srcdir, srcfib)) {
  418.       while (ExNext(srcdir, srcfib)) {
  419.          if (CHECKBREAK())
  420.             break;
  421.          if (srcfib->fib_DirEntryType < 0) {
  422.             printf("%*s%s..",(level-1) * 6," ",srcfib->fib_FileName);
  423.             fflush(stdout);
  424.             ierr = copyfile(srcfib->fib_FileName,srcdir,srcfib->fib_FileName,destdir);
  425.             if (ierr)
  426.                break;
  427.          } else {
  428.             if (recur) {
  429.                cwd = CurrentDir(srcdir);
  430.                if (srclock = Lock(srcfib->fib_FileName, ACCESS_READ)) {
  431.                   CurrentDir(destdir);
  432.                   if (!(destlock = Lock(srcfib->fib_FileName))) {
  433.                      destlock = CreateDir(srcfib->fib_FileName);
  434.                      printf("%*s%s (Dir)....[Created]\n",(level-1) * 6,
  435.                                 " ",srcfib->fib_FileName);
  436.  
  437.                         /* UnLock and re Lock if newly created
  438.                            for file_date() to work properly
  439.                         */
  440.                      if (destlock) UnLock(destlock);
  441.                      destlock = Lock(srcfib->fib_FileName);
  442.                   }
  443.                   else
  444.                      printf("%*s%s (Dir)\n",(level-1) * 6," ",srcfib->fib_FileName);
  445.                   if (destlock) {
  446.                      ierr = copydir(srclock, destlock, recur);
  447.                      UnLock(destlock);
  448.                   } else {
  449.                      ierr = (int)((long)IoErr());
  450.                   }
  451.                   UnLock(srclock);
  452.                } else {
  453.                   ierr = (int)((long)IoErr());
  454.                }
  455.                CurrentDir(cwd);
  456.                if (ierr)
  457.                   break;
  458.             }
  459.          }
  460.       }
  461.    } else {
  462.       ierr = (int)((long)IoErr());
  463.    }
  464.    --level;
  465.    FreeMem(srcfib, (long)sizeof(FIB));
  466.    return(ierr);
  467. }
  468.  
  469.  
  470. copyfile(srcname, srcdir, destname, destdir)
  471. char *srcname, *destname;
  472. BPTR srcdir, destdir;
  473. {
  474. BPTR cwd;
  475. BPTR f1, f2;
  476. long i;
  477. int stat,ierr;
  478. char *buf;
  479. struct DPTR *dp, *dps = NULL;
  480.  
  481. if ((buf = (char *)AllocMem(8192L, MEMF_PUBLIC|MEMF_CLEAR))==NULL)
  482.     { ierr = 103; goto fail; }
  483. ierr = 0;
  484. cwd = CurrentDir(srcdir);
  485. if ((f1=Open(srcname, MODE_OLDFILE))==NULL)
  486.     { errstr = srcname; ierr = 205; goto fail; }
  487. dps = dopen(srcname,&stat);
  488. CurrentDir(destdir);
  489. if (cp_update)
  490.     {
  491.     dp=dopen(destname, &stat);
  492.     if ( dptrtosecs(dp) >= dptrtosecs(dps) &&
  493.         !strcmp(dps->fib->fib_FileName, dp->fib->fib_FileName))
  494.         { dclose(dp); Close(f1); printf("..not newer\n"); goto fail; }
  495.     dclose(dp);
  496.     }
  497. if ((f2=Open(destname, MODE_NEWFILE))==NULL)
  498.     { Close(f1); ierr = (int)((long)IoErr()); errstr=destname; goto fail;  }
  499. while (i = Read(f1, buf, 8192L))
  500.     if (Write(f2, buf, i) != i) { ierr = (int)((long)IoErr()); break; }
  501. Close(f2);
  502. Close(f1);
  503. if (!ierr)
  504.     {
  505.     if (cp_date) file_date(&dps->fib->fib_Date, destname);
  506.     printf("..copied\n");
  507.     }
  508. else DeleteFile(destname);
  509. fail:
  510.  dclose(dps);
  511.  if (buf) FreeMem(buf, 8192L);
  512.  CurrentDir(cwd);
  513.  return(ierr);
  514. }
  515.  
  516. do_touch()
  517. {
  518. struct DateStamp ds;
  519. register unsigned int i;
  520. DateStamp(&ds);
  521. for (i=1; i<ac; i++) if (file_date(&ds, av[i])) ierror(av[i],500);
  522. return 0;
  523. }
  524.  
  525. file_date(date,name)
  526. struct DateStamp *date;
  527. char *name;
  528. {
  529. long packargs[7];
  530. UBYTE *ptr;
  531. struct MsgPort *task;
  532. BPTR dirlock;
  533. struct DPTR *tmp;
  534. int stat;
  535.  
  536. if (!(task = (struct MsgPort *)DeviceProc(name))) return(1);
  537. if (tmp = dopen(name, &stat)) {
  538.     dirlock = ParentDir(tmp->lock);
  539.     ptr=AllocMem(65L,MEMF_PUBLIC);
  540.     CtoBStr(tmp->fib->fib_FileName,(ULONG)ptr >> 2L,64L);
  541.     dclose(tmp);
  542.     packargs[1]=dirlock;
  543.     packargs[2]=(ULONG)ptr >> 2L;
  544.     packargs[3]=(long)date;
  545.     SendPacket(ACTION_SET_DATE,packargs,task);
  546.     UnLock(dirlock);
  547.     FreeMem(ptr,65L);
  548.     }
  549. return 0;
  550. }
  551.  
  552. do_addbuffers()
  553. {
  554. long packargs[7];
  555. long n;
  556. struct MsgPort *task=(struct MsgPort *)DeviceProc(av[1]);
  557.  
  558. if (!task) { ierror(av[1],510); return 20; }
  559. n=myatoi(av[2],1,32767); if (Errno) return 20;
  560. packargs[0]=n;
  561. SendPacket(ACTION_MORE_CACHE,packargs,task);
  562. return 0;
  563. }
  564.  
  565. do_relabel()
  566. {
  567. long packargs[7];
  568. UBYTE *ptr;
  569. struct MsgPort *task=(struct MsgPort *)DeviceProc(av[1]);
  570.  
  571. if (!task) { ierror(av[1],510); return 20; }
  572. ptr=AllocMem(65L,MEMF_PUBLIC);
  573. CtoBStr(av[2],(ULONG)ptr >> 2L,64L);
  574. packargs[0]=(ULONG)ptr >> 2L;
  575. SendPacket(ACTION_RENAME_DISK,packargs,task);
  576. FreeMem(ptr,65L);
  577. changedisk(task);
  578. return 0;
  579. }
  580.  
  581. do_diskchange()
  582. {
  583. struct MsgPort *task=(struct MsgPort *)DeviceProc(av[1]);
  584.  
  585. if (!task) { ierror(av[1],510); return 20; }
  586. changedisk(task);
  587. return 0;
  588. }
  589.  
  590. changedisk(task)
  591. struct MsgPort *task;
  592. {
  593. long packargs[7];
  594.  
  595. packargs[0]=1L;
  596. SendPacket(ACTION_INHIBIT,packargs,task);
  597. packargs[0]=0L;
  598. SendPacket(ACTION_INHIBIT,packargs,task);
  599. }
  600.